home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / pbmplus / libtiff / tif_unix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-28  |  3.7 KB  |  169 lines  |  [TEXT/CWIE]
  1. #ifndef lint
  2. static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_unix.c,v 1.6 93/08/25 09:34:24 sam Exp $";
  3. #endif
  4.  
  5. /*
  6.  * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
  7.  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and 
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  * 
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20.  * 
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library UNIX-specific Routines.
  31.  */
  32. #include "tiffiop.h"
  33. #include <unistd.h>
  34. #include <stdlib.h>
  35.  
  36. static tsize_t
  37. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  38. {
  39.     return (read((int) fd, buf, (size_t) size));
  40. }
  41.  
  42. static tsize_t
  43. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  44. {
  45.     return (write((int) fd, buf, (size_t) size));
  46. }
  47.  
  48. static toff_t
  49. _tiffSeekProc(thandle_t fd, off_t off, int whence)
  50. {
  51.     return ((toff_t) lseek((int) fd, (off_t) off, whence));
  52. }
  53.  
  54. static int
  55. _tiffCloseProc(thandle_t fd)
  56. {
  57.     return (close((int) fd));
  58. }
  59.  
  60. #include <sys/stat.h>
  61.  
  62. static toff_t
  63. _tiffSizeProc(thandle_t fd)
  64. {
  65. #ifdef _AM29K
  66.     long fsize;
  67.     return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
  68. #else
  69.     struct stat sb;
  70.     return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
  71. #endif
  72. }
  73.  
  74. #ifdef MMAP_SUPPORT
  75. #include <sys/mman.h>
  76.  
  77. static int
  78. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  79. {
  80.     toff_t size = _tiffSizeProc(fd);
  81.     if (size != (toff_t) -1) {
  82.         *pbase = (tdata_t)
  83.             mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
  84.         if (*pbase != (tdata_t) -1) {
  85.             *psize = size;
  86.             return (1);
  87.         }
  88.     }
  89.     return (0);
  90. }
  91.  
  92. static void
  93. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  94. {
  95.     (void) munmap(base, (off_t) size);
  96. }
  97. #else /* !MMAP_SUPPORT */
  98. static int
  99. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  100. {
  101.     return (0);
  102. }
  103.  
  104. static void
  105. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  106. {
  107. }
  108. #endif /* !MMAP_SUPPORT */
  109.  
  110. /*
  111.  * Open a TIFF file descriptor for read/writing.
  112.  */
  113. TIFF*
  114. TIFFFdOpen(int fd, const char* name, const char* mode)
  115. {
  116.     TIFF* tif;
  117.  
  118.     tif = TIFFClientOpen(name, mode,
  119.         (thandle_t) fd,
  120.         _tiffReadProc, _tiffWriteProc,
  121.         _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
  122.         _tiffMapProc, _tiffUnmapProc);
  123.     if (tif)
  124.         tif->tif_fd = fd;
  125.     return (tif);
  126. }
  127.  
  128. /*
  129.  * Open a TIFF file for read/writing.
  130.  */
  131. TIFF*
  132. TIFFOpen(const char* name, const char* mode)
  133. {
  134.     static const char module[] = "TIFFOpen";
  135.     int m, fd;
  136.  
  137.     m = _TIFFgetMode(mode, module);
  138.     if (m == -1)
  139.         return ((TIFF*)0);
  140. #ifdef _AM29K
  141.     fd = open(name, m);
  142. #else
  143.     fd = open(name, m, 0666);
  144. #endif
  145.     if (fd < 0) {
  146.         TIFFError(module, "%s: Cannot open", name);
  147.         return ((TIFF *)0);
  148.     }
  149.     return (TIFFFdOpen(fd, name, mode));
  150. }
  151.  
  152. void*
  153. _TIFFmalloc(size_t s)
  154. {
  155.     return (malloc(s));
  156. }
  157.  
  158. void
  159. _TIFFfree(void* p)
  160. {
  161.     free(p);
  162. }
  163.  
  164. void*
  165. _TIFFrealloc(void* p, size_t s)
  166. {
  167.     return (realloc(p, s));
  168. }
  169.